/**
 * 
 */
package com.chennan.work.jiuqi;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringReader;
import java.io.Writer;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.nio.file.DirectoryStream;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;

import org.springframework.core.io.Resource;

/**
 * 文件工具类
 * 
 * @author huangkaibin
 *
 */
public class IOUtils {

	private static final int BUFFER_SIZE = 8192;

	/**
	 * 复制整个目录
	 * 
	 * @param source 源目录
	 * @param target 目标目录路径
	 * @throws IOException 如果复制过程中出现错误，则抛出这个异常
	 */
	public static void copyDirectory(String source, String target) throws IOException {
		copyDirectory(new File(source), target);
	}

	/**
	 * 复制整个目录
	 * 
	 * @param source 源目录
	 * @param target 目标目录路径
	 * @throws IOException 如果复制过程中出现错误，则抛出这个异常
	 */
	public static void copyDirectory(File source, File target) throws IOException {
		copyDirectory(source, target.getAbsolutePath());
	}

	/**
	 * 复制整个目录
	 * 
	 * @param source 源目录
	 * @param target 目标目录路径
	 * @throws IOException 如果复制过程中出现错误，则抛出这个异常
	 */
	public static void copyDirectory(File source, String target) throws IOException {
		String sourcePath = source.getAbsolutePath();
		Queue<File> list = new LinkedList<File>();
		list.add(source);
		while (!list.isEmpty()) {
			File file = list.poll();
			String path = file.getAbsolutePath();
			String relativePath = path.substring(sourcePath.length());
			File f = new File(target, relativePath);
			if (file.isDirectory()) {
				ensureMakeDirectory(f);
				File[] children = file.listFiles();
				Collections.addAll(list, children);
			} else {
				copyFile(file, f);
			}
		}
	}

	/**
	 * 复制单个文件
	 * 
	 * @param source 源文件
	 * @param target 目标文件
	 * @throws IOException 如果复制过程中出现错误，则抛出这个异常
	 */
	public static void copyFile(File source, File target) throws IOException {
		File parent = target.getParentFile();
		if (!parent.exists()) {
			ensureMakeDirectory(parent);
		}
		FileInputStream in = null;
		FileOutputStream out = null;
		try {
			in = new FileInputStream(source);
			out = new FileOutputStream(target);
			copyStream(in, out);
			target.setLastModified(source.lastModified());
		} finally {
			close(in);
			close(out);
		}
	}

	/**
	 * 复制单个文件
	 * 
	 * @param source 源
	 * @param target 目标文件
	 * @throws IOException 如果复制过程中出现错误，则抛出这个异常
	 */
	public static void copyFile(Resource source, File target) throws IOException {
		File parent = target.getParentFile();
		if (!parent.exists()) {
			ensureMakeDirectory(parent);
		}
		InputStream in = null;
		FileOutputStream out = null;
		try {
			in = source.getInputStream();
			out = new FileOutputStream(target);
			copyStream(in, out);
			target.setLastModified(source.lastModified());
		} finally {
			close(in);
			close(out);
		}
	}

	/**
	 * 复制流，把内容从输入流复制到输出流。
	 * 
	 * @param in  源文件输入流
	 * @param out 目标文件输出流
	 * @throws IOException 如果复制过程中出现错误，则抛出这个异常
	 */
	public static void copyStream(InputStream in, OutputStream out) throws IOException {
		byte[] buf = new byte[BUFFER_SIZE];
		int count = 0;
		while ((count = in.read(buf)) > 0) {
			out.write(buf, 0, count);
		}
	}

	/**
	 * 复制流，把内容从输入流复制到输出流。
	 * 
	 * @param in  源文件输入流
	 * @param out 目标文件输出流
	 * @throws IOException 如果复制过程中出现错误，则抛出这个异常
	 */
	public static void copyStream(Reader in, Writer out) throws IOException {
		char[] buf = new char[BUFFER_SIZE];
		int count = 0;
		while ((count = in.read(buf)) > 0) {
			out.write(buf, 0, count);
		}
	}

	/**
	 * 删除指定的文件或目录
	 * 
	 * @param path 文件或目录的路径
	 * @return 如果删除成功，就返回<tt>true</tt>，否则返回<tt>false</tt>
	 */
	public static boolean delete(String path) {
		try {
			ensureDelete(path);
			return true;
		} catch (IOException e) {
			return false;
		}
	}

	/**
	 * 删除指定的文件或目录
	 * 
	 * @param path 文件或目录的路径
	 * @return 如果删除成功，就返回<tt>true</tt>，否则返回<tt>false</tt>
	 */
	public static boolean delete(Path path) {
		try {
			ensureDelete(path);
			return true;
		} catch (IOException e) {
			return false;
		}
	}

	/**
	 * 删除指定的文件或目录
	 * 
	 * @param file 文件或目录
	 * @return 如果删除成功，就返回<tt>true</tt>，否则返回<tt>false</tt>
	 */
	public static boolean delete(File file) {
		try {
			ensureDelete(file);
			return true;
		} catch (IOException e) {
			return false;
		}
	}

	/**
	 * 删除指定的文件或目录，如果删除失败，就抛出异常
	 * 
	 * @param path 文件或目录的路径
	 * @throws IOException 如果删除失败，就抛出该异常
	 */
	public static void ensureDelete(String path) throws IOException {
		if (path == null) {
			throw new IllegalArgumentException("Null path"); //$NON-NLS-1$
		}
		Path p = FileSystems.getDefault().getPath(path);
		ensureDelete(p);
	}

	/**
	 * 删除指定的文件或目录，如果删除失败，就抛出异常
	 * 
	 * @param path 文件或目录的路径
	 * @throws IOException 如果删除失败，就抛出该异常
	 */
	public static void ensureDelete(Path path) throws IOException {
		if (path == null) {
			throw new IllegalArgumentException("Null path"); //$NON-NLS-1$
		}
		if (!Files.exists(path)) {
			return;
		}
		List<Path> list = new ArrayList<>(256);
		list.add(path);
		for (int i = 0; i < list.size(); ++i) {
			Path p = list.get(i);
			if (Files.isDirectory(p)) {
				try (DirectoryStream<Path> dir = Files.newDirectoryStream(p)) {
					for (Path e : dir) {
						list.add(e);
					}
				}
			}
		}
		for (int i = list.size() - 1; i >= 0; --i) {
			Path p = list.get(i);
			Files.delete(p);
		}
	}

	/**
	 * 删除指定的文件或目录，如果删除失败，就抛出异常
	 * 
	 * @param path 文件或目录
	 * @throws IOException 如果删除失败，就抛出该异常
	 */
	public static void ensureDelete(File file) throws IOException {
		if (file == null) {
			throw new IllegalArgumentException("Null file"); //$NON-NLS-1$
		}
		ensureDelete(file.toPath());
	}

	/**
	 * 判断指定的文件是否存在
	 * 
	 * @param path 文件路径
	 * @return 如果文件存在，就返回<tt>true</tt>；如果文件不存在，或者路径指定的不是文件，就返回<tt>false</tt>。
	 */
	public static boolean existsFile(String path) {
		if (path == null) {
			throw new IllegalArgumentException("Null path"); //$NON-NLS-1$
		}
		Path p = FileSystems.getDefault().getPath(path);
		return Files.isRegularFile(p);
	}

	/**
	 * 判断指定的文件是否存在
	 * 
	 * @param directory 文件所在目录
	 * @param fileName  文件名
	 * @return 如果文件存在，就返回<tt>true</tt>；如果文件不存在，或者路径指定的不是文件，就返回<tt>false</tt>。
	 */
	public static boolean existsFile(String directory, String fileName) {
		if (directory == null) {
			throw new IllegalArgumentException("Null directory path"); //$NON-NLS-1$
		}
		if (fileName == null) {
			throw new IllegalArgumentException("Null fileName"); //$NON-NLS-1$
		}
		Path p = FileSystems.getDefault().getPath(directory, fileName);
		return Files.isRegularFile(p);
	}

	/**
	 * 判断指定的目录是否存在
	 * 
	 * @param path 目录路径
	 * @return 如果目录存在，就返回<tt>true</tt>；如果目录不存在，或者路径指定的不是目录，就返回<tt>false</tt>。
	 */
	public static boolean existsDirectory(String path) {
		if (path == null) {
			throw new IllegalArgumentException("Null path"); //$NON-NLS-1$
		}
		Path p = FileSystems.getDefault().getPath(path);
		return Files.isDirectory(p);
	}

	/**
	 * 判断指定的文件是否存在
	 * 
	 * @param file 文件
	 * @return 如果文件存在，就返回<tt>true</tt>；如果文件不存在，或者路径指定的不是文件，就返回<tt>false</tt>。
	 */
	public static boolean existsFile(File file) {
		if (file == null) {
			throw new IllegalArgumentException("Null file path"); //$NON-NLS-1$
		}
		Path p = file.toPath();
		return Files.isRegularFile(p);
	}

	/**
	 * 判断指定的目录是否存在
	 * 
	 * @param directory 目录
	 * @return 如果目录存在，就返回<tt>true</tt>；如果目录不存在，或者路径指定的不是目录，就返回<tt>false</tt>。
	 */
	public static boolean existsDirectory(File directory) {
		if (directory == null) {
			throw new IllegalArgumentException("Null directory path"); //$NON-NLS-1$
		}
		Path p = directory.toPath();
		return Files.isDirectory(p);
	}

	/**
	 * 创建指定的目录
	 * 
	 * @param path 目录路径
	 * @return 如果创建成功或者目录原来就存在，就返回<tt>true</tt>，否则返回<tt>false</tt>
	 */
	public static boolean makeDirectory(String path) {
		try {
			ensureMakeDirectory(path);
			return true;
		} catch (IOException e) {
			return false;
		}
	}

	/**
	 * 创建指定的目录
	 * 
	 * @param directory 目录
	 * @return 如果创建成功或者目录原来就存在，就返回<tt>true</tt>，否则返回<tt>false</tt>
	 */
	public static boolean makeDirectory(File directory) {
		try {
			ensureMakeDirectory(directory);
			return true;
		} catch (IOException e) {
			return false;
		}
	}

	/**
	 * 创建指定的目录。如果创建成功或者目录原来就存在，就直接返回，否则抛出异常。
	 * 
	 * @param directory 目录
	 * @throws IOException 如果创建目录失败，就抛出异常
	 */
	public static void ensureMakeDirectory(File directory) throws IOException {
		if (directory == null) {
			throw new IllegalArgumentException("Null directory"); //$NON-NLS-1$
		}
		Path path = directory.toPath();
		if (Files.isDirectory(path)) {
			return;
		}
		Files.createDirectories(path);
	}

	/**
	 * 创建指定的目录。如果创建成功或者目录原来就存在，就直接返回，否则抛出异常。
	 * 
	 * @param path 目录路径
	 * @throws IOException 如果创建目录失败，就抛出异常
	 */
	public static void ensureMakeDirectory(String path) throws IOException {
		if (path == null) {
			throw new IllegalArgumentException("Null directory path"); //$NON-NLS-1$
		}
		Path p = FileSystems.getDefault().getPath(path);
		if (Files.isDirectory(p)) {
			return;
		}
		Files.createDirectories(p);
	}

	/**
	 * 读取流的内容
	 * 
	 * @param in 输入流
	 * @return 以字符串的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static String readString(InputStream in) throws IOException {
		return readString(new InputStreamReader(in));
	}

	/**
	 * 以指定字符集读取流的内容
	 * 
	 * @param in      输入流
	 * @param charset 字符集
	 * @return 以字符串的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static String readString(InputStream in, Charset charset) throws IOException {
		return readString(new InputStreamReader(in, charset));
	}

	/**
	 * 读取文件的内容
	 * 
	 * @param in 文件输入流
	 * @return 以字符串的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static String readString(Reader in) throws IOException {
		StringBuilder buffer = new StringBuilder();
		char[] b = new char[BUFFER_SIZE];
		int count;
		while ((count = in.read(b)) > 0) {
			buffer.append(b, 0, count);
		}
		return buffer.toString();
	}

//	/**
//	 * 读取文件的内容
//	 * @param filePath 文件路径
//	 * @return 以字符串的形式返回文件内容
//	 * @throws IOException 如果读取文件失败，就抛出该异常
//	 */
//	public static String readFileString(String filePath) throws IOException {
//		return readFileString(new File(filePath));
//	}

//	/**
//	 * 读取文件的内容
//	 * @param file 文件
//	 * @return 以字符串的形式返回文件内容
//	 * @throws IOException 如果读取文件失败，就抛出该异常
//	 */
//	public static String readFileString(File file) throws IOException {
//		String charsetName = EncodingDetect.detectJavaCharsetName(file);
//		if (charsetName != null) {
//			try (Reader in = new InputStreamReader(new FileInputStream(file), charsetName)) {
//				return readString(in);
//			}
//		} else {
//			try (Reader in = new FileReader(file)) {
//				return readString(in);
//			}
//		}
//	}

	/**
	 * 以指定字符集读取文件的内容
	 * 
	 * @param filePath 文件路径
	 * @param charset  字符集
	 * @return 以字符串的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static String readFileString(String filePath, Charset charset) throws IOException {
		return readFileString(new File(filePath), charset);
	}

	/**
	 * 以指定字符集读取文件的内容
	 * 
	 * @param file    文件
	 * @param charset 字符集
	 * @return 以字符串的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static String readFileString(File file, Charset charset) throws IOException {
		try (Reader in = new InputStreamReader(new FileInputStream(file), charset)) {
			return readString(in);
		}
	}

//	/**
//	 * 读取url的内容
//	 * @param url
//	 * @return 以字符串的形式返回文件内容
//	 * @throws IOException 如果读取文件失败，就抛出该异常
//	 */
//	public static String readUrlString(String url) throws IOException {
//		return readUrlString(new URL(url));
//	}

//	/**
//	 * 读取url的内容
//	 * @param url
//	 * @return 以字符串的形式返回文件内容
//	 * @throws IOException 如果读取文件失败，就抛出该异常
//	 */
//	public static String readUrlString(URL url) throws IOException {
//		Reader in = null;
//		try {
//			String charsetName = EncodingDetect.detectJavaCharsetName(url);
//			if (charsetName != null) {
//				in = new InputStreamReader(url.openStream(), charsetName);
//				return readString(in);
//			} else {
//				in = new InputStreamReader(url.openStream());
//				return readString(in);
//			}
//		} finally {
//			close(in);
//		}
//	}

	/**
	 * 以指定字符集读取url的内容
	 * 
	 * @param url
	 * @param charset 字符集
	 * @return 以字符串的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static String readUrlString(String url, Charset charset) throws IOException {
		return readUrlString(new URL(url), charset);
	}

	/**
	 * 以指定字符集读取url的内容
	 * 
	 * @param url
	 * @param charset 字符集
	 * @return 以字符串的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static String readUrlString(URL url, Charset charset) throws IOException {
		try (Reader in = new InputStreamReader(url.openStream(), charset)) {
			return readString(in);
		}
	}

	/**
	 * 读取输入流的内容
	 * 
	 * @param in 输入流
	 * @return 以字节数组的形式返回输入流内容
	 * @throws IOException 如果读取输入流失败，就抛出该异常
	 */
	public static byte[] readBytes(InputStream in) throws IOException {
		return readBytes(in, -1);
	}

	/**
	 * 从输入流中读取不超过maxSize大小的内容
	 * 
	 * @param in      输入流
	 * @param maxSize 读取数据的大小限制，如果传-1表示不限制。
	 * @return 以字节数组的形式返回输入流内容
	 * @throws IOException 如果读取输入流失败，就抛出该异常
	 */
	public static byte[] readBytes(InputStream in, long maxSize) throws IOException {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		byte[] b = new byte[getBufferSize(maxSize)];
		int count;
		long size = 0;
		while (((count = in.read(b, 0, getReadLength(b.length, size, maxSize))) > 0)
				&& (maxSize == -1 || size < maxSize)) {
			size += count;
			out.write(b, 0, count);
		}
		return out.toByteArray();
	}

	private static int getBufferSize(long maxSize) {
		return maxSize > -1 ? (int) Math.min(BUFFER_SIZE, maxSize) : BUFFER_SIZE;
	}

	private static int getReadLength(int length, long size, long maxSize) {
		return maxSize > -1 ? (int) Math.min(length, maxSize - size) : length;
	}

	/**
	 * 读取文件的内容
	 * 
	 * @param filePath 文件路径
	 * @return 以字节数组的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static byte[] readFileBytes(String filePath) throws IOException {
		return readFileBytes(new File(filePath));
	}

	/**
	 * 读取文件的内容
	 * 
	 * @param file 文件
	 * @return 以字节数组的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static byte[] readFileBytes(File file) throws IOException {
		try (InputStream in = new FileInputStream(file)) {
			return readBytes(in);
		}
	}

	/**
	 * 读取URL的内容
	 * 
	 * @param url
	 * @return 以字节数组的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static byte[] readUrlBytes(String url) throws IOException {
		return readUrlBytes(new URL(url));
	}

	/**
	 * 读取URL的内容
	 * 
	 * @param url
	 * @return 以字节数组的形式返回文件内容
	 * @throws IOException 如果读取文件失败，就抛出该异常
	 */
	public static byte[] readUrlBytes(URL url) throws IOException {
		try (InputStream in = url.openStream()) {
			return readBytes(in);
		}
	}

	public static final void readLines(InputStream input, Charset charset, Collection<String> c) throws IOException {
		if (input == null) {
			throw new IllegalArgumentException();
		}
		if (charset == null) {
			throw new IllegalArgumentException();
		}
		if (c == null) {
			throw new IllegalArgumentException();
		}
		try (InputStreamReader isr = new InputStreamReader(input, charset)) {
			try (BufferedReader br = new BufferedReader(isr)) {
				String s = null;
				while ((s = br.readLine()) != null) {
					s = s.trim();
					if (s.length() > 0) {
						c.add(s);
					}
				}
			}
		}
	}

	public static final String[] readLines(InputStream input, Charset charset) throws IOException {
		List<String> l = new ArrayList<String>();
		readLines(input, charset, l);
		return l.toArray(new String[l.size()]);
	}

	/**
	 * 把指定的内容写到文件中
	 * 
	 * @param filePath 文件路径
	 * @param content  文件的内容字符串
	 * @throws IOException 如果写文件失败，就抛出该异常
	 */
	public static void writeFile(String filePath, String content) throws IOException {
		writeFile(new File(filePath), content);
	}

	/**
	 * 把指定的内容写到文件中
	 * 
	 * @param filePath 文件路径
	 * @param in       输入流
	 * @throws IOException 如果写文件失败，就抛出该异常
	 */
	public static void writeFile(String filePath, InputStream in) throws IOException {
		writeFile(new File(filePath), in);
	}

	/**
	 * 把指定的内容写到文件中
	 * 
	 * @param filePath 文件路径
	 * @param in       输入流
	 * @throws IOException 如果写文件失败，就抛出该异常
	 */
	public static void writeFile(String filePath, Reader in) throws IOException {
		writeFile(new File(filePath), in);
	}

	/**
	 * 把指定的内容写到文件中
	 * 
	 * @param file    文件
	 * @param content 文件的内容字符串
	 * @throws IOException 如果写文件失败，就抛出该异常
	 */
	public static void writeFile(File file, String content) throws IOException {
		try (Reader in = new StringReader(content)) {
			writeFile(file, in);
		}
	}

	/**
	 * 把指定的内容写到文件中
	 * 
	 * @param file 文件
	 * @param in   输入流
	 * @throws IOException 如果写文件失败，就抛出该异常
	 */
	public static void writeFile(File file, InputStream in) throws IOException {
		try (OutputStream out = new FileOutputStream(file)) {
			copyStream(in, out);
		}
	}

	/**
	 * 把指定的内容写到文件中
	 * 
	 * @param file 文件
	 * @param in   输入流
	 * @throws IOException 如果写文件失败，就抛出该异常
	 */
	public static void writeFile(File file, Reader in) throws IOException {
		try (Writer out = new FileWriter(file)) {
			copyStream(in, out);
		}
	}

	/**
	 * 把URL中指定的内容保存到指定的文件中
	 * 
	 * @param source      源URL路径
	 * @param destination 目标保存文件路径
	 * @throws IOException 如果保存过程中发生异常，就抛出异常
	 */
	public static void copyURLToFile(URL source, String destination) throws IOException {
		copyURLToFile(source, new File(destination));
	}

	/**
	 * 把URL中指定的内容保存到指定的文件中
	 * 
	 * @param source            源URL路径
	 * @param destination       目标保存文件路径
	 * @param connectionTimeout 连接超时设置，不能小于0，单位是毫秒
	 * @param readTimeout       读取超时设置，不能小于0，单位是毫秒
	 * @throws IOException 如果保存过程中发生异常，就抛出异常
	 */
	public static void copyURLToFile(URL source, String destination, int connectionTimeout, int readTimeout)
			throws IOException {
		copyURLToFile(source, new File(destination), connectionTimeout, readTimeout);
	}

	/**
	 * 把URL中指定的内容保存到指定的文件中
	 * 
	 * @param source      源URL路径
	 * @param destination 目标保存文件
	 * @throws IOException 如果保存过程中发生异常，就抛出异常
	 */
	public static void copyURLToFile(URL source, File destination) throws IOException {
		try (InputStream input = source.openStream()) {
			writeFile(destination, input);
		}
	}

	/**
	 * 把URL中指定的内容保存到指定的文件中
	 * 
	 * @param source            源URL路径
	 * @param destination       目标保存文件
	 * @param connectionTimeout 连接超时设置，不能小于0，单位是毫秒
	 * @param readTimeout       读取超时设置，不能小于0，单位是毫秒
	 * @throws IOException 如果保存过程中发生异常，就抛出异常
	 */
	public static void copyURLToFile(URL source, File destination, int connectionTimeout, int readTimeout)
			throws IOException {
		URLConnection connection = source.openConnection();
		connection.setConnectTimeout(connectionTimeout);
		connection.setReadTimeout(readTimeout);
		try (InputStream input = connection.getInputStream()) {
			writeFile(destination, input);
		}
	}

	/**
	 * 关闭实现Closeable接口的类，包括InputStream、OutputStream、Reader、Writer、Channel等。
	 * 如果在关闭过程中发生异常，则把异常截获，并把信息输出到控制台中。
	 * 
	 * @param closeable 实现Closeable接口的类
	 */
	public static void close(Closeable closeable) {
		if (closeable != null) {
			try {
				closeable.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 获取Java临时目录，这个目录一般也是操作系统配置的临时目录
	 * 
	 * @return Java临时目录
	 */
	public static String getTempDir() {
		return System.getenv("java.io.tmpdir"); //$NON-NLS-1$
	}

	/**
	 * 创建并返回程序用的临时目录，这个临时目录是在Java临时目录下的一个空的子目录
	 * 
	 * @return 临时目录
	 */
	public static String generateAppTempDir() {
		String temp = getTempDir();
		long l = System.currentTimeMillis();
		File f = new File(temp, String.valueOf(l));
		Random r = new Random();
		while (existsDirectory(f)) {
			l = r.nextLong();
			f = new File(temp, String.valueOf(l));
		}
		makeDirectory(f);
		return f.getAbsolutePath();
	}

	public static void writeLog(String[] logs) {
		FileOutputStream fos = null;
		OutputStreamWriter osw = null;
		BufferedWriter bw = null;
		try {
			fos = new FileOutputStream(new File("record.meta"));
			osw = new OutputStreamWriter(fos, "UTF-8");
			bw = new BufferedWriter(osw);
			for (String arr : logs) {
				bw.write(arr + "\t\n");
			}

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bw.close();
				osw.close();
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}
